תרגול 12. Standard Template Library כתיבת אלגוריתמים גנריים מצביעים חכמים

Transcription

1 תרגול 12 Standard Template Library כתיבת אלגוריתמים גנריים מצביעים חכמים

2 ספרית התבניות הסטנדרטית קיימת בכל מימוש של ++C מכילה אוספים (Containers) ואלגוריתמים. משתמשת בתבניות :(templates) אוספי הנתונים גנריים האלגוריתמים המסופקים גנריים מאפשרת הרחבה ע"י המשתמש שומרת על ביצועים גבוהים 2

3 Vector נכיר תחילה את האוסף הפשוט ביותר בספריה.vector מערך סדור של איברים מאפשר גישה לכל איבר באוסף מאפשר הוספת והסרת איברים הערה: הקוד בשקפים הוא חלקי וחסרות בו תכונות נוספות ומתקדמות יותר של אוספי ה- STL. דוגמאות הקוד מתרכזות בשימוש בסיסי ופשוט. 3

4 template<typename T> class vector { vector(); vector(const vector& c); vector(size_t num, const T& val = T()); ~vector(); T& operator[](size_t index); const T& operator[](size_t index) const; vector operator=(const vector& v); מתודות נבחרות של vector הערה: גישה בעזרת אופרטור ][ אינה בטוחה אינה מוודאת את חוקיות האינדקס ; T& at(size_t loc); const T& at(size_t loc) const; void pop_back(); void push_back(const T& val); size_t size() const; לעומת זאת, גישה בעזרת at() זורקת חריגה במקרה והאינדקס אינו חוקי מסוג out_of_range 4

5 דוגמאות לשימוש ב- vector int main() { vector<int> v1; // empty vector vector<int> v2(20, 8);// 20 integers, all of value 8 for(size_t i = 0; i < v2.size(); ++i) { cout << v2[i]; // Unsafe access by index for(int i = 0; i < 10; ++i) { v1.push_back(i); // Inserts items at the end of the vector while(v1.size() > 0) { v1.pop_back(); const vector<int> copy(v1);//safely copies a vector 5 return 0;

6 יתרונות ניהול זיכרון ע"י המחלקה לא צריך לזכור לשחרר ידנית את המערך ניתן לשנות את גודל המערך בקלות ניתן ליצור העתקים ולבצע השמות בקלות גישה בטוחה רק כאשר משתמשים ב-() at 6

7 שאלה: כיצד ניתן ליצור וקטור בטוח? בד"כ מחיר בדיקת גישה לוקטור אינו משפיע על ביצועי התכנית. ניצור גרסה של וקטור המוודאת לכל גישה האם היא חוקית: template<typename T> class SafeVector : public vector<t> { SafeVector() : vector<t>() { SafeVector(int s) : vector<t>(s) { T& operator[](int i) { return at(i); const T& operator[](int i) const { return at(i); ; 7

8 List דומה לוקטור, אך המימוש הוא ברשימה מקושרת. שימוש ברשימה מקושרת מאפשר הוספת איברים מהירה יותר, אך אינו מאפשר גישה מהירה לאמצע האוסף. ההבדל העיקרי בין list האוספים מנשק דומה. ל- vector הוא במימוש, לכן לשני השימוש במנשק דומה מאפשר למשתמש להחליף בקלות את סוג האוסף בשימוש גם בשלבים מאוחרים. כאמור, סיבוכיות היא שיקול משני בד"כ ולכן ניתן להשתמש ב- vector, ורק בהמשך כשיש צורך ברשימה מקושרת ניתן לעבור לשימוש בה. 8

9 template<typename T> class list { list(); list(const list& c); list(size_t num, const T& val = T()); ~list(); מתודות נבחרות מ- list נוספו מתודות להסרת והוספת איברים גם בראש הרשימה ; list operator=(const list& v); void pop_back(); void push_back(const T& val); void pop_front(); void push_front(const T& val); size_t size() const; נעלמו המתודות לגישה לאיבר באמצע הרשימה כיצד נוכל לאפשר גישה למשתמש בצורה נוחה? 9

10 Iterators ע"מ לאפשר מעבר סדור על איברי אוסף נשתמש בעצם מסוג.Iterator נדרוש את הפעולות הבאות מ- Iterator )בינתיים(: קידום שינוי האיטרטור כך שיצביע לאיבר הבא קריאה החזרת האיבר המוצבע ע"י האיטרטור השוואה בדיקה האם שני איטרטורים מצביעים לאותו איבר int* array = new int[n];... int* i = array; cout << *i << endl; // Reading the iterator i++; // Advancing the iterator by 1 if (i == array+n) { // Comparing to iterators cout << "End of array!" << endl; איטרטור אינו מחלקה, אלא מושג.(concept) למשל מצביע הוא איטרטור עבור מערך של C: 10

11 Iterators & STL כל האוספים המאפשרים מעבר על איבריהם ב- STL מספקים iterator בעזרתו ניתן לעבור על איבריהם. המתודה begin() מחזירה iterator מתאים לתחילת האוסף. המתודה end() מחזירה iterator מתאים לאיבר האיבר האחרון. "דמה" אחרי למשתמש לא אכפת כיצד ממומש האיטרטור! 11

12 דוגמה לשימוש בוקטור הדפסת איברי :vector for(vector<int>::iterator i = v.begin();i!= v.end(); ++i) { cout << *i << endl; הדפסת איברי :list for(list<int>::iterator i = l.begin(); i!= l.end(); ++i) { cout << *i << endl; בצורה דומה ניתן לגשת לכל אוסף ב- STL הטיפוס עבור ה- iterator מוגדר בתוך כל אוסף בצורה הבאה: container<int>::iterator 12

13 const_iterator vector<int> v; vector<int>::iterator i = v.begin(); *i = 7; // O.K.!! // *i is int& בנוסף כל אוסף מגדיר גם טיפוס.const_iterator כך ניתן להגן על האוסף מפני שינויים כאשר הוא מוגדר כ- const const vector<int> v; vector<int>::const_iterator i = v.begin(); *i = 7; // syntax error! // *i is const int& טיפוס האיטרטור המוחזר נקבע בעזרת העמסה על המתודות המתאימות 13

14 עוד שימושים רוב המתודות עבור האוספים משתמשות באיטרטורים כדי לציין מיקומים. הוספת איבר לתוך רשימה ממוינת: list<double>::iterator i = mylist.begin(); while (i!= mylist.end() && num < *i){ ++i; mylist.insert(i, num); // Insert num before I myvector.erase(v.begin()+4); מחיקת האיבר החמישי בוקטור: 14

15 סוגי איטרטורים אוספים שונים מחזירים איטרטורים שונים. ל- list, למשל, יש bidirectional iterator המאפשר קידום האיטרטור עם אופרטור++ והחזרתו לאחור עם אופרטור--. ל- vector יש random access iterator המאפשר גם חיבור מספרים לאיטרטור וחישוב הפרש בין שני איטרטורים )בדומה למצביע(. 15

16 עוד?STL ל- vector נוספים. ו- list מס' רב של מתודות ואופרטורים כמעט כל פעולה שעולה בדעתכם לבצע כבר ממומשת ב- STL. ניתן פשוט לחפש באינטרנט: למשל. יש עוד אוספים ב- STL. למשל,set בקורס. stack ומבני נתונים נוספים שלא נלמדו 16

17 כתיבת אלגוריתמים גנריים ברצוננו לכתוב פונקציה אשר מוצאת את האיבר המקסימלי. כיצד נוכל לאפשר לפונקציה לעבוד על כל אוסף אפשרי? 17

18 אלגוריתם max template<typename Iterator> Iterator max(iterator start, Iterator end) { if (start == end) { return end; Iterator maximum = start; for(iterator i = ++start; i!= end; ++i) { if (*i > *maximum) { maximum = i; return maximum; 18

19 - שימושים אלגוריתם max דוגמאות לשימוש: מציאת הערך הגדול ביותר בוקטור. int m = *max(myvector.begin(), myvector.end()); מחיקת האיבר הגדול ביותר ברשימה. mylist.erase(max(mylist.begin(), mylist.end())); 19

20 יתרונות אלגוריתם יחיד מתאים לכל המקרים: אוספים שונים רק חלקים מהאוסף ניתנים למעבר קל להתאים קוד קיים שיעבוד עם האלגוריתם למשל שימוש באלגוריתם עבור מערך רגיל של C: int* myarray = new int[size];... int m = *max(myarray, myarray+size); 20

21 algorithm מלבד מבני הנתונים ה- STL מכיל גם אוסף אלגוריתמים מועילים הניתנים להפעלה על כל מבנה נתונים מתאים: חלקם פשוטים: Iterator find(iterator start, Iterator end, const T& val); void sort(iterator start, Iterator end); וחלקם פחות: void random_shuffle(iterator start, Iterator end); 21

22 Function Objects במקום לשלוח מצביעים של פונקציות ב- STL משתמשים ב- objects. Function Function object הוא כל עצם המעמיס את אופרטור )( )אופרטור ההפעלה( 22

23 class LessThanZero { public: bool operator()(int m) const { ; int main() { return m < 0; LessThanZero isnegative; cout << isnegative(-4) << endl; // true cout << isnegative(6) << endl; // false דוגמה ל- Object Function את המחלקה מגדירים עם אופרטור ההפעלה. במקרה זה אנו מגדירים את המחלקה כפונקציה המקבלת int ומחזירה.bool return 0; 23

24 class SumOf { public: ; bool operator()(int a, int b, int s) { int main() { return a+b == s; SumOf issum; דוגמה ל- Object Function אופרטור ההפעלה ניתן להגדרה עם כל מספר של פרמטרים. cout << issum(2,3,5) << endl; // true cout << issum(1,2,5) << endl; // false return 0; 24

25 class LessThan { public: LessThan(int n) : n(n) { bool operator()(int m) const{ private: ; int n; return m < n; דוגמה ל- Object Function עד עכשיו לא הצגנו את היתרון על שימוש במצביע לפונקציה: בניגוד למצביעים לפונקציות, ניתן לזכור מצב ב- Object Function ולכן ניתן להשתמש באותה מחלקה למס' פונקציות השונות רק בפרמטר כלשהו. int main() { LessThan isless(5); LessThan isless2(8); cout << isless(4) << endl; // true cout << isless(6) << endl; // false cout << isless2(6) << endl; // true return 0; 25 )היזכרו כיצד פתרנו את אותה בעיה ב- C ( שימו לב להבדל בין קריאה לבנאי להפעלת האופרטור המתבצעת על עצם מהטיפוס.

26 - דוגמה Function Objects נוכל להשתמש בפונקציה שהגדרנו בקריאה לאלגוריתמים מסוימים: template<typename Iterator, typename Predicate> Iterator find_if(iterator first, Iterator last, Predicate pred) { for (; first!= last; first++) if (pred(*first)) break; return first; vector<int> v; vector<int>::iterator i = find_if(v.begin(),v.end(),lessthan(2)); vector<int>::iterator j = 26 find_if(v.begin(),v.end(),lessthan(7));

27 דוגמה נוספת ל- Objects Function ניצור קריטריון מיון חדש למספרים שלמים, לפי ערך המספר מודולו m: נמיין class LessThanModulo { public: LessThanModulo(int m) : m(m) { bool operator()(int a, int b) {return a%m < b%m; private: ; int m; בכדי למיין פשוט נקרא לאלגוריתם המיון עם פרמטר נוסף: sort(v.begin(), v.end(), LessThanModulo(5)); 27

28 הוספת איטרטורים ניזכר במחלקת String שהגדרנו בתרגול 9, כיצד נוכל להשתמש באלגוריתמים הקיימים עבור מחלקה זו? עלינו להוסיף תמיכה באיטרטורים במחלקה. 28

29 הוספת תמיכה באיטרטורים ב- String class String { private: int length; char* value; public:... typedef char* iterator; typedef const char* const_iterator; במקרה של,String במצביע ל- char. נוכל פשוט להשתמש שימו לב להגדרות הטיפוסים שאנו מוסיפים, כדי שהמשתמש לא יצטרך לדעת בעצמו שאנו משתמשים במצביע ל- char ; 29 iterator begin() { return value; const_iterator begin() const { return value; iterator end() { return value+length; const_iterator end() const { return value+length;...

30 שימוש האלגוריתם transform מפעיל פונקציה על תחום מסוים ומציב לתחום אחר את ערך ההחזרה. toupper() נשתמש בו ובפונקצית הספריה של C להמיר מחרוזת לאותיות גדולות. כדי transform(str.begin(),str.end(),str.begin(),toupper); 30

31 סיכום הספריה הסטנדרטית בנויה מאוספים ואלגוריתמים איטרטורים מהווים את הדבק המאפשר לשני חלקים אלו להישאר גנריים אלגוריתמים איטרטורים אוספים 31

32 מצביעים חכמים מצביעים אחראים לרובן המוחלט של שגיאות הזיכרון הצלחנו להיפטר מרוב השימושים הלא בטוחים במצביעים בעזרת שימוש בתכונות של ++C ניצול בנאים, הורסים והשמות לטיפול מסודר בזיכרון. שימוש ב- STL ואוספים לטיפול מסודר באלגוריתמים של מבני הנתונים. 32

33 בעיה vector<shape> shapes; Circle circle(3.5); shapes.push_back(circle); // Only the "Shape part" // is copied!! ירושות דורשות שימוש במצביעים vector<shape*> shapes;... delete shapes.back(); shapes.pop_back(); // We must delete ourselves // when removing items from // the vector 33 עבודה עם מצביעים מוחקת את כל היתרונות שהשגנו! צריך לנהל זיכרון בצורה מפורשת בכל מקום בתוכנית!

34 smart_ptr נוכל ליצור מחלקה, המתנהגת כמצביע אך מוסיפה התנהגות נוספת. למשל, שחרור העצם המוצבע בהריסת המצביע. כלומר ניצור מצביע יותר. "חכם" 34

35 smart_ptr template<typename T> class smart_ptr { private: T* pointeddata; typedef T element_type; public: explicit smart_ptr(t* ptr = NULL) : pointeddata(ptr) { ~smart_ptr() { delete pointeddata; T& operator*() const { return *pointeddata; T* operator->() const { return pointeddata; ; 35

36 יתרונות שימוש ב- smart_ptr מה קורה במקרה וה- new השני נכשל בכל אחת מהפונקציות? int good() { smart_ptr<shape> ptr1(new Circle(5.0)); smart_ptr<shape> ptr2(new Square(5.0));... int bad() { Shape* ptr1 = new Circle(5.0); Shape* ptr2 = new Square(5.0);... 36

37 העתקה כיצד יתנהג המצביע במקרה של העתקה? מה צריכה להיות ההתנהגות עבור בנאי העתקה והשמה? ניסיון ראשון: העתקת המצביע תבצע "העברת בעלות" של העצם המוצבע התנהגות זו ממומשת ב- auto_ptr הקיים בספריה הסטנדרטית של ++C. מאפשרת העברת/החזרת עצמים מוקצים דינאמית מפונקציות. 37

38 שימוש ב- auto_ptr שימוש ב- auto_ptr כדי להחזיר עצם חדש: בניגוד למצביע רגיל מוגדר בקוד מי אחראי לשחרור העצם. auto_ptr<shape> createmyshape() { return auto_ptr<shape>(new Circle(5.0)); שימוש ב- auto_ptr כדי לחסוך העתקות: auto_ptr<vector<int>> getnprimenumbers (int n) {... 38

39 העתקה בעיה! ההתנהגות עבור אינה סטנדרטית "העתקה" של auto_ptr ההעתק אינו זהה למקור! לא ניתן לאחסן auto_ptr בתוך אוספים של ה- STL מאחר והם מסתמכים על תכונה זו. כיצד ניתן ליצור מצביע חכם שגם יאפשר העתקה נכונה? 39

40 שיפור מצביע משותף shared_ptr<object> Object* ptr int* counter shared_ptr<object> Object* ptr int* counter ניצור מצביע חכם יותר מתקדם: shared_ptr shared_ptr<object> Object* ptr int* counter 2 Object Object 1 לכל עצם מוצבע נשמור מונה הצבעות, וכל המצביעים ישתמשו במונה זה על מנת לדעת מתי יש לשחרר את העצם המוצבע. 40

41 template<typename T> class shared_ptr { private: T* pointeddata; int* referencecounter; משתנים ואינווריאנטה typedef T element_type; 41 void checkinvariant() const { assert((pointeddata && referencecounter && (*referencecounter)>0) (!pointeddata &&!referencecounter));

42 עדכון המונה void increasecount() { checkinvariant(); if (referencecounter) { (*referencecounter)++; void decreasecount() { checkinvariant(); if(referencecounter && --*referencecounter == 0){ delete referencecounter; delete pointeddata; referencecounter = NULL; pointeddata = NULL; 42

43 אתחול ושחרור public: explicit shared_ptr(t* ptr = NULL) : pointeddata(ptr), referencecounter(pointeddata? new int(1) : NULL){ shared_ptr(const shared_ptr<t>& other) : pointeddata(other.pointeddata), referencecounter(pointeddata? other.referencecounter : NULL) { increasecount(); checkinvariant(); 43

44 אתחול ושחרור template <typename S> friend class shared_ptr; template <typename S> shared_ptr(const shared_ptr<s>& other) : pointeddata(other.pointeddata), referencecounter(pointeddata? other.referencecounter : NULL) { increasecount(); checkinvariant(); ~shared_ptr() { checkinvariant(); decreasecount(); checkinvariant(); מטרת הבנאי היא לאפשר השמה בין shared_ptr של טיפוסים שונים, למשל בגלל הורשה. 44

45 גישה למצביע T& operator*() const { checkinvariant(); assert(pointeddata!= NULL); return *pointeddata; T* operator->() const { checkinvariant(); assert(pointeddata!= NULL); return pointeddata; T* get() const { 45 checkinvariant(); return pointeddata; המתודה get() מסופקת בכדי לאפשר שימוש של המחלקה גם עם קוד ישן שאינו תומך ב- shared_ptr

46 אופרטור השמה template<typename S> shared_ptr<t>& operator=( shared_ptr<s>& other) { checkinvariant(); other.increasecount(); decreasecount(); referencecounter = other.referencecounter; pointeddata = other.pointeddata; checkinvariant(); return *this; מה קורה במקרה של הצבה עצמית? מדוע אין צורך בבדיקה? 46

47 עוד מתודות שימושיות operator bool() { checkinvariant(); return pointeddata; המרה לערך בוליאני תאפשר לנו לבדוק האם המצביע תקין כמו מצביע רגיל. void reset() { decreasecount(); pointeddata = NULL; referencecounter = NULL; המתודה reset() מאפשרת למשתמש צורה נוחה יותר לאיפוס מצביע ; 47

48 פונקציות השוואה template <typename T, typename S> bool operator==(const shared_ptr<t>& first, const shared_ptr<s>& second) { return first.get() == second.get(); template <typename T, typename S> bool operator!=(const shared_ptr<t>& first, return!(first==second); const shared_ptr<s>& second) { template <typename T, typename S> bool operator<(const shared_ptr<t>& first, 48 const shared_ptr<s>& second) { return first.get() < second.get();

49 דוגמאות כל ההעתקות בטוחות! האחרון שיוצא סוגר את האור! vector<shared_ptr<shape> > function() { shared_ptr<shape> shape(new Polygon(points)); shared_ptr<circle> circle(new Circle(5.0)); shared_ptr<square> square(new Square(2.0)); vector<shared_ptr<shape> > vec; vec.push_back(shape); vec.push_back(circle); vec.push_back(square); vector<shared_ptr<shape> > copy = vec; copy.pop_back(); return copy; 49 תרגיל לבית )למשועממים(: מיצאו את הצורה שיש למחוק בסוף הפונקציה... איך היה נראה הקוד ללא שימוש במצביעים חכמים?

50 יתרונות כל הקוד לניהול הזיכרון נכתב רק פעם אחת. קל לחלוק עצמים אשר לא ברור מי האחרון שמשתמש בהם. ניתן להשתמש בכל האוספים שראינו עם מצביעים ובפרט עם ירושות. הקוד נהייה פשוט יותר ועמיד יותר בפני שגיאות זיכרון. מה קורה בדוגמה הקודמת אם אחת מהקצאות הזיכרון נכשלת? מה היה קורה ללא המצביעים החכמים? 50

51 לא הכל מושלם! shared_ptr כי השחרור הוא ע"י אינו מתאים לאחסון מצביע למערך! delete ולא.delete[] ניתן ליצור בקלות shared_array שיתאים לבעיה זו. אבל ממילא עדיף להשתמש ב- vector! המצביעים לא ישוחררו אם קיימים קשרים מעגליים במקרה זה יש לנקות את המצביעים בצורה מפורשת עם.reset פתרון טוב יותר למקרה זה דורש היכרות עם מצביע חכם נוסף והזמן קצר מלהכיל אותו. 51

52 לסיכום כתיבת ספריות ב-++ C היא מסובכת. השימוש בהן לעומת זאת הוא פשוט. מאפשר כתיבת קוד טוב יותר בפחות זמן ופחות שורות. ניתן למצוא מימוש פשוט של shared_ptr באתר הקורס. 52